

/*
https://www.acwing.com/problem/content/description/260/

N
 个小朋友（编号为 0,1,2,…,N−1
）一起玩石头剪子布游戏。

其中一人为裁判，其余的人被分为三个组（有可能有一些组是空的），第一个组的小朋友只能出石头，第二个组的小朋友只能出剪子，第三个组的小朋友只能出布，而裁判可以使用任意手势。

你不知道谁是裁判，也不知道小朋友们是怎么分组的。

然后，孩子们开始玩游戏，游戏一共进行 M
 轮，每轮从 N
 个小朋友中选出两个小朋友进行猜拳。

你将被告知两个小朋友猜拳的胜负结果，但是你不会被告知两个小朋友具体使用了哪种手势。

比赛结束后，你能根据这些结果推断出裁判是谁吗？

如果可以的话，你最早在第几轮可以找到裁判。

输入格式
输入可能包含多组测试用例

每组测试用例第一行包含两个整数 N
 和 M
。

接下来 M
 行，每行包含两个整数 a,b
，中间夹着一个符号(>,=,<)，表示一轮猜拳的结果。

两个整数为小朋友的编号，a>b 表示 a
 赢了 b
，a=b 表示 a
 和 b
 平手，a<b 表示 a
 输给了 b
。

输出格式
每组测试用例输出一行结果，如果找到裁判，且只能有一个人是裁判，则输出裁判编号和确定轮数。

如果找到裁判，但裁判的人选多于 1
 个，则输出 Can not determine。

如果根据输入推断的结果是必须没有裁判或者必须有多个裁判，则输出 Impossible。

具体格式可参考样例。

数据范围
1≤N≤500
,
0≤M≤2000
输入样例：
3 3
0<1
1<2
2<0
3 5
0<1
0>1
1<2
1>2
0<2
4 4
0<1
0>1
2<3
2>3
1 0
输出样例：
Can not determine
Player 1 can be determined to be the judge after 4 lines
Impossible
Player 0 can be determined to be the judge after 0 lines
*/


/*
C++ 代码
/*
本题一种有三种情况，石头、剪刀、布，每个人都是固定的种类，然后相互会存在大小关系，因此可以用带权并查集。

然后本题还有一个裁判机制，裁判可以随便出，虽然有裁判在的对局，由于裁判可以随便出所以关系是可能存在矛盾的，
但是除了裁判在的其他关系应该都是合法的。

因此我们可以枚举所有人去找裁判。

对于每个人，枚举所有不包含这个人的对局：
1. 如果这些对局都是合法的，说明这个人可能是裁判，裁判人数+1。
2. 如果遇到第一个不合法的对局，说明这个人不是裁判，这时需要记录对局编号，表示最早发现这个人不是裁判的位置。

最终会得出可能的裁判人数：
1. 裁判人数 > 1，可能的裁判有多个，输出不确定。
2. 裁判人数 = 1，只有一个裁判，需要输出裁判的编号和最早确定裁判的轮数，
	我们需要确定其他所有人不是裁判才能确定当前人是裁判。
   因此需要枚举其他所有不是裁判的人，从最早判断它们不是裁判的轮数中取一个最大值，
   就是最早能排除其他人确定当前人是裁判的位置。
3. 裁判人数 = 0，没有裁判，输出没有。
*/



/*
#include <iostream>
#include <cstring>

using namespace std;

const int N = 510, M = 2010;

int n, m;
int p[N], d[N]; //带权并查集
bool st[N]; //记录每个人是否是裁判
int f[N]; //f[i] 表示第i个人最早确定不是裁判的轮数
int a[M], b[M]; //a[i],b[i],c[i] 表示第i轮对局是 a[i] c[i] b[i]
char c[M];

int find(int x)
{
    if(x != p[x])
    {
        int root = find(p[x]);
        d[x] = (d[x] + d[p[x]]) % 3;
        p[x] = root;
    }
    return p[x];
}

bool check(int k) //判断第k轮对局是否合法
{
    int x = a[k], y = b[k]; //取出两个人
    int t = 1; //记录大小关系，>,< 是 1，= 是0
    if(c[k] == '=') t = 0;
    if(c[k] == '>') swap(x, y); //保证 x < y

    int px = find(x), py = find(y);
    if(px == py) //同一集合
    {
        if(d[x] != (d[y] + t) % 3) return false; //距离不符，对局不合法
    }
    else //不在同一集合
    {
        //合并
        p[px] = py;
        d[px] = (d[y] - d[x] + t + 3) % 3; //这里+3取模，保证正余数
    }
    return true; //到这说明对局合法
}

int main()
{
    while(cin >> n >> m)
    {
        for(int i = 1; i <= m; i++) scanf("%d%c%d", &a[i], &c[i], &b[i]);

        memset(f, 0, sizeof f); //重置轮数

        int cnt = 0, num = 0; //cnt 表示可能是裁判的人数，num 表示裁判的编号
        for(int i = 0; i < n; i++) //枚举所有人
        {
            for(int j = 0; j < n; j++) p[j] = j, d[j] = 0; //初始化并查集

            bool is_umpire = true; //记录当前人有没有可能是裁判
            for(int j = 1; j <= m; j++) //枚举对局
                if(a[j] != i && b[j] != i && !check(j)) //如果其他对局中存在矛盾，说明当前人不是裁判
                {
                    is_umpire = false; //修改标记
                    f[i] = j; //记录最早确定当前人不是裁判的轮数
                    break; //跳出循环
                }

            if(is_umpire) //如果当前人可能是裁判
            {
                cnt++; //裁判人数+1
                num = i; //记录裁判编号
            }
        }

        if(!cnt) puts("Impossible"); //没有裁判
        else if(cnt > 1) puts("Can not determine"); //多个裁判
        else
        {
            int res = 0; //记录最早能确定裁判的轮数
            for(int i = 0; i < n; i++) //枚举所有人
                if(i != num) //如果当前人不是裁判
                    res = max(res, f[i]); //更新最早确定轮数
            printf("Player %d can be determined to be the judge after %d lines\n", num, res);
        }
    }
    return 0;
}

*/